{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Importing Libraries","metadata":{}},{"cell_type":"code","source":"! pip install biosppy   ","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:35:22.933055Z","iopub.execute_input":"2021-08-02T10:35:22.933483Z","iopub.status.idle":"2021-08-02T10:35:34.313803Z","shell.execute_reply.started":"2021-08-02T10:35:22.933399Z","shell.execute_reply":"2021-08-02T10:35:34.312619Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"Collecting biosppy\n  Downloading biosppy-0.7.3.tar.gz (85 kB)\n\u001b[K     |████████████████████████████████| 85 kB 1.3 MB/s eta 0:00:011\n\u001b[?25hCollecting bidict\n  Downloading bidict-0.21.2-py2.py3-none-any.whl (37 kB)\nRequirement already satisfied: h5py in /opt/conda/lib/python3.7/site-packages (from biosppy) (2.10.0)\nRequirement already satisfied: matplotlib in /opt/conda/lib/python3.7/site-packages (from biosppy) (3.4.2)\nRequirement already satisfied: numpy in /opt/conda/lib/python3.7/site-packages (from biosppy) (1.19.5)\nRequirement already satisfied: scikit-learn in /opt/conda/lib/python3.7/site-packages (from biosppy) (0.23.2)\nRequirement already satisfied: scipy in /opt/conda/lib/python3.7/site-packages (from biosppy) (1.6.3)\nRequirement already satisfied: shortuuid in /opt/conda/lib/python3.7/site-packages (from biosppy) (1.0.1)\nRequirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from biosppy) (1.15.0)\nRequirement already satisfied: joblib in /opt/conda/lib/python3.7/site-packages (from biosppy) (1.0.1)\nRequirement already satisfied: opencv-python in /opt/conda/lib/python3.7/site-packages (from biosppy) (4.5.2.54)\nRequirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.7/site-packages (from matplotlib->biosppy) (0.10.0)\nRequirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.7/site-packages (from matplotlib->biosppy) (2.8.1)\nRequirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.7/site-packages (from matplotlib->biosppy) (1.3.1)\nRequirement already satisfied: pyparsing>=2.2.1 in /opt/conda/lib/python3.7/site-packages (from matplotlib->biosppy) (2.4.7)\nRequirement already satisfied: pillow>=6.2.0 in /opt/conda/lib/python3.7/site-packages (from matplotlib->biosppy) (8.2.0)\nRequirement already satisfied: threadpoolctl>=2.0.0 in /opt/conda/lib/python3.7/site-packages (from scikit-learn->biosppy) (2.1.0)\nBuilding wheels for collected packages: biosppy\n  Building wheel for biosppy (setup.py) ... \u001b[?25ldone\n\u001b[?25h  Created wheel for biosppy: filename=biosppy-0.7.3-py2.py3-none-any.whl size=95409 sha256=04ce713690a58fbc476a2b15fdf6a96d548a8980166dc96830dcd07b2c8a14c0\n  Stored in directory: /root/.cache/pip/wheels/2f/4f/8f/28b2adc462d7e37245507324f4817ce1c64ef2464f099f4f0b\nSuccessfully built biosppy\nInstalling collected packages: bidict, biosppy\nSuccessfully installed bidict-0.21.2 biosppy-0.7.3\n\u001b[33mWARNING: Running pip as root will break packages and permissions. You should install packages reliably by using venv: https://pip.pypa.io/warnings/venv\u001b[0m\n","output_type":"stream"}]},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nimport wfdb\nimport os                                                                                                  \nimport gc\nimport scipy       \nimport sklearn\nfrom pathlib import Path\nfrom sklearn.utils import shuffle\nfrom sklearn.manifold import TSNE\nimport seaborn as sns\nfrom sklearn import preprocessing\nimport shutil\nimport math\nimport random\nfrom scipy.spatial import distance\nfrom biosppy.signals import ecg\nfrom scipy.interpolate import PchipInterpolator","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:35:34.315680Z","iopub.execute_input":"2021-08-02T10:35:34.315973Z","iopub.status.idle":"2021-08-02T10:35:41.668822Z","shell.execute_reply.started":"2021-08-02T10:35:34.315939Z","shell.execute_reply":"2021-08-02T10:35:41.667455Z"},"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"code","source":"try:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()  # TPU detection\n    print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])\nexcept ValueError:\n    raise BaseException('ERROR: Not connected to a TPU runtime; please see the previous cell in this notebook for instructions!')\n\ntf.config.experimental_connect_to_cluster(tpu)\ntf.tpu.experimental.initialize_tpu_system(tpu)\ntpu_strategy = tf.distribute.experimental.TPUStrategy(tpu)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:37:52.890827Z","iopub.execute_input":"2021-08-02T10:37:52.891233Z","iopub.status.idle":"2021-08-02T10:37:58.579053Z","shell.execute_reply.started":"2021-08-02T10:37:52.891200Z","shell.execute_reply":"2021-08-02T10:37:58.578087Z"},"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"Running on TPU  ['10.0.0.2:8470']\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Dataset Creation","metadata":{}},{"cell_type":"markdown","source":"## MIT-BIH Dataset","metadata":{}},{"cell_type":"code","source":"####### Dataset Creation  \n###### Reading Dataset\n\n##### Function to read a record from single dataset\ndef data_read_mit(filepath):\n    \n    \"\"\"\n    Function to read the the inputs from MIT-BIH Dataset\n    INPUTS:- \n    1)filepath: Path to the csv file\n    \n    OUTPUTS:-\n    1)Output_signal: Output 1D array signal \n    \"\"\"\n    return (np.array(pd.read_csv(filepath,index_col=0).iloc[:,[0]]))   \n    \n##### Function to Required Annotations from .txt files\ndef feature_extractor(txt_file_path):\n    \n    \"\"\"\n       Function to extract time series data \n       from a .txt file\n    \"\"\"\n    \n    #### Reading File\n    line_list = []\n\n    with open(txt_file_path, 'r') as reader:\n\n    # Read and print the entire file line by line\n        line = reader.readline()\n        while line != '':  # The EOF char is an empty string\n            #print(line, end='')\n            line_list.append(line)\n            line = reader.readline()\n    \n    #### Taking the Time Step Data\n    line_list = line_list[1:]\n    \n    #### Splitting the Collected Text Strings and Converting them into Floating type values\n    new_list = []\n\n    for item in line_list:\n        for idx,sub_item in enumerate(item.split()):\n            if(idx == 1):\n                new_list.append(int(sub_item))\n                break\n    \n    ### Returning the feature extracted list as numpy array\n    return np.array(new_list)\n\n###### Function to Segment Signals\n##### Constants\nFS = 500\nW_LEN = 256\nW_LEN_1_4 = 256 // 4\nW_LEN_3_4 = 3 * (256 // 4)\n\n##### Function\ndef segmentSignals(signal, r_peaks_annot, normalization=True, person_id= None, file_id=None):\n    \n    \"\"\"\n    Segments signals based on the detected R-Peak\n    Args:\n        signal (numpy array): input signal\n        r_peaks_annot (int []): r-peak locations.\n        normalization (bool, optional): apply z-normalization or not? . Defaults to True.\n        person_id ([type], optional): [description]. Defaults to None.\n        file_id ([type], optional): [description]. Defaults to None.\n    Returns:\n            [tuple(numpy array,numpy array)]: segmented signals and refined r-peaks\n    \"\"\"\n    def refine_rpeaks(signal, r_peaks):\n        \"\"\"\n        Refines the detected R-peaks. If the R-peak is slightly shifted, this assigns the \n        highest point R-peak.\n        Args:\n            signal (numpy array): input signal\n            r_peaks (int []): list of detected r-peaks\n        Returns:\n            [numpy array]: refined r-peaks\n        \"\"\"\n\n        r_peaks2 = np.array(r_peaks)            # make a copy\n        for i in range(len(r_peaks)):\n            r = r_peaks[i]          # current R-peak\n            small_segment = signal[max(0,r-100):min(len(signal),r+100)]         # consider the neighboring segment of R-peak\n            r_peaks2[i] = np.argmax(small_segment) - 100 + r_peaks[i]           # picking the highest point\n            r_peaks2[i] = min(r_peaks2[i],len(signal))                          # the detected R-peak shouldn't be outside the signal\n            r_peaks2[i] = max(r_peaks2[i],0)                                    # checking if it goes before zero    \n        return r_peaks2                     # returning the refined r-peak list\n    \n    segmented_signals = []                      # array containing the segmented beats\n    \n    r_peaks = np.array(r_peaks_annot)\n    r_peaks = refine_rpeaks(signal, r_peaks)\n    skip_len = 5 # Parameter to specify number of r_peaks in one signal\n    max_seq_len = 1280 # Parameter to specify maximum sequence length\n    \n    for r_curr in range(0,int(r_peaks.shape[0]-(skip_len-1)),skip_len):\n        if ((r_peaks[r_curr]-W_LEN_1_4)<0) or ((r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4)>=len(signal)):           # not enough signal to segment\n            continue\n        segmented_signal = np.array(signal[r_peaks[r_curr]-W_LEN_1_4:r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4])        # segmenting a heartbeat\n        segmented_signal = list(segmented_signal)\n        #print(segmented_signal.shape)\n        \n        if(len(segmented_signal) < 1280):\n            for m in range(int(1280-len(segmented_signal))): # Zero Padding\n                segmented_signal.append(0)\n        else:\n            segmented_signal = (segmented_signal[:int(max_seq_len)])\n            \n        segmented_signal = np.array(segmented_signal)\n        \n        if(segmented_signal.shape != (1280,1)):    \n            segmented_signal = np.reshape(segmented_signal,(1280,1))\n            \n        if (normalization):             # Z-score normalization\n            if abs(np.std(segmented_signal))<1e-6:          # flat line ECG, will cause zero division error\n                continue\n            segmented_signal = (segmented_signal - np.mean(segmented_signal)) / np.std(segmented_signal)            \n              \n        #if not np.isnan(segmented_signal).any():                    # checking for nan, this will never happen\n            segmented_signals.append(segmented_signal)\n\n    return segmented_signals,r_peaks           # returning the segmented signals and the refined r-peaks","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Looping for Reading the Entire Dataset - OpenSet Testing\n\n! mkdir './5_Beat_Ecg_MITBIH_1' # Generating major database of datasets\ncurrent_index = 1\n\nmit_dbs_path = '../input/mitbih-database'\nfor i in range(0,96,2): # Loop over all the files\n    print(i)\n    print(np.sort(os.listdir(mit_dbs_path))[i])\n    rec_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i])) # Path Selection\n    attr_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i+1])) # Path Selction\n    \n    signal_current = data_read_mit(rec_file_path) # Current ECG Signal\n    r_peaks_current = feature_extractor(attr_file_path) # R-peaks\n    seg_signal_current,new_r_peaks = (segmentSignals(signal_current,list(r_peaks_current))) # Segmented ECG Signals\n    #seg_signal_current = np.array(seg_signal_current)\n    #print(seg_signal_current.shape[0])\n    \n    if(i == 48):\n        current_index = current_index-1\n        current_storage_path = './5_Beat_Ecg_MITBIH_1'+'/person'+str(current_index)\n        #Path(current_storage_path).mkdir(parents=True, exist_ok=True)\n    \n        for j in range(len(seg_signal_current)):\n            file_name_current = current_storage_path+'/Extra'+str(j)\n            np.savez_compressed(file_name_current,seg_signal_current[j])\n            \n        current_index = current_index+1\n    \n    else:\n        current_storage_path = './5_Beat_Ecg_MITBIH_1'+'/person'+str(current_index)\n        Path(current_storage_path).mkdir(parents=True, exist_ok=True)\n    \n        for j in range(len(seg_signal_current)):\n            file_name_current = current_storage_path+'/'+str(j)\n            np.savez_compressed(file_name_current,seg_signal_current[j])\n            \n        current_index = current_index+1","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Creation of Numpy Arrays\n##### Defining Essentials\ndata_folder = './5_Beat_Ecg_MITBIH_1'\nX_train = []\nX_dev = []\ny_train = []     \ny_dev = []\n\n##### Looping Over to populate the dataset\nfor index,sub_data_folder in enumerate(np.sort(os.listdir(data_folder))):\n    sub_data_folder_path = os.path.join(data_folder,sub_data_folder)\n    \n    #if(index <= 33):\n        \n    for idx,item in enumerate(np.sort(os.listdir(sub_data_folder_path))): # Looping Over a person's folder\n        item_path = os.path.join(sub_data_folder_path,item)\n\n        #### Train on Past Test on Present (TPTP)\n        if(idx <= int(np.round(len(os.listdir(sub_data_folder_path))))):\n            X_train.append(np.load(item_path,allow_pickle=True)['arr_0'])\n            y_train.append(index)\n            \n    print('Person'+' '+str(index+1)+'s data taken')\n    \n##### Creation of Numpy Arrays\nX_train_CD_train_MITBIH = np.array(X_train)\ny_train_CD_train_MITBIH = np.array(y_train)\n\nprint(np.array(X_train).shape)\nprint(np.array(y_train).shape)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## PTB Dataset","metadata":{}},{"cell_type":"code","source":"###### Constants\nFS = 360\nW_LEN = 256\nW_LEN_1_4 = 256 // 4\nW_LEN_3_4 = 3 * (256 // 4)\n\n###### Function to Segment Signals\n\ndef segmentSignals(signal, r_peaks_annot, normalization=True, person_id= None, file_id=None):\n    \n    \"\"\"\n    Segments signals based on the detected R-Peak\n    Args:\n        signal (numpy array): input signal\n        r_peaks_annot (int []): r-peak locations.\n        normalization (bool, optional): apply z-normalization or not? . Defaults to True.\n        person_id ([type], optional): [description]. Defaults to None.\n        file_id ([type], optional): [description]. Defaults to None.\n    Returns:\n            [tuple(numpy array,numpy array)]: segmented signals and refined r-peaks\n    \"\"\"\n    def refine_rpeaks(signal, r_peaks):\n        \"\"\"\n        Refines the detected R-peaks. If the R-peak is slightly shifted, this assigns the \n        highest point R-peak.\n        Args:\n            signal (numpy array): input signal\n            r_peaks (int []): list of detected r-peaks\n        Returns:\n            [numpy array]: refined r-peaks\n        \"\"\"\n        r_peaks2 = np.array(r_peaks)            # make a copy\n        for i in range(len(r_peaks)):\n            r = r_peaks[i]          # current R-peak\n            small_segment = signal[max(0,r-100):min(len(signal),r+100)]         # consider the neighboring segment of R-peak\n            r_peaks2[i] = np.argmax(small_segment) - 100 + r_peaks[i]           # picking the highest point\n            r_peaks2[i] = min(r_peaks2[i],len(signal))                          # the detected R-peak shouldn't be outside the signal\n            r_peaks2[i] = max(r_peaks2[i],0)                                    # checking if it goes before zero    \n        return r_peaks2                     # returning the refined r-peak list\n    \n    segmented_signals = []                      # array containing the segmented beats\n    \n    r_peaks = np.array(r_peaks_annot)\n\n    r_peaks = refine_rpeaks(signal, r_peaks)\n    skip_len = 5 # Parameter to specify number of r_peaks in one signal\n    max_seq_len = 1280 # Parameter to specify maximum sequence length\n    \n    for r_curr in range(0,int(r_peaks.shape[0]-(skip_len-1)),skip_len):\n        if ((r_peaks[r_curr]-W_LEN_1_4)<0) or ((r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4)>=len(signal)):           # not enough signal to segment\n            continue\n        segmented_signal = np.array(signal[r_peaks[r_curr]-W_LEN_1_4:r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4])        # segmenting a heartbeat\n        segmented_signal = list(segmented_signal)\n        #print(segmented_signal.shape)\n        \n        if(len(segmented_signal) < 1280):\n            for m in range(int(1280-len(segmented_signal))): # Zero Padding\n                segmented_signal.append(0)\n        else:\n            segmented_signal = (segmented_signal[:int(max_seq_len)])\n            \n        segmented_signal = np.array(segmented_signal)\n        \n        if(segmented_signal.shape != (1280,1)):    \n            segmented_signal = np.reshape(segmented_signal,(1280,1))\n            \n        if (normalization):             # Z-score normalization\n            if abs(np.std(segmented_signal))<1e-6:          # flat line ECG, will cause zero division error\n                continue\n            segmented_signal = (segmented_signal - np.mean(segmented_signal)) / np.std(segmented_signal)            \n              \n        #if not np.isnan(segmented_signal).any():                    # checking for nan, this will never happen\n            segmented_signals.append(segmented_signal)\n\n    return segmented_signals,r_peaks           # returning the segmented signals and the refined r-peaks\n\n###### Function to Read Records\n\ndef read_rec(rec_path):\n\n    \"\"\" \n    Function to read record and return Segmented Signals\n\n    INPUTS:-\n    1) rec_path : Path of the Record\n\n    OUTPUTS:-\n    1) seg_sigs : Final Segmented Signals\n\n    \"\"\"\n    number_of_peaks = 5 # For extracting the required number of peaks                                    \n    full_rec = (wfdb.rdrecord(rec_path)).p_signal[:,0] # Entire Record - Taking Signal from Lead-1\n\n    f = PchipInterpolator(np.arange(int(full_rec.shape[0])),full_rec) # Fitting Interpolation Function\n    num_samples = int(full_rec.shape[0]) # Total Samples in 1000Hz Signal\n    num_samples_final = int(num_samples*(360/1000))\n    x_samp = (np.arange(num_samples)*(1000/360))[:num_samples_final] # Fixing Interpolation Input Values\n    full_rec_interp = f(x_samp)  # Intepolating Values \n    \n    r_peaks_init = ecg.hamilton_segmenter(full_rec_interp,360)[0] # R-Peak Segmentation and input is the signal frequency of 500Hz in this case\n    final_peak_index = r_peaks_init[int(r_peaks_init.shape[0] - int((r_peaks_init.shape[0]%number_of_peaks)))-1]\n    r_peaks_final = r_peaks_init[:final_peak_index] # Final Number of R_Peaks\n    full_rec_final = full_rec_interp[:int(r_peaks_final[-1]+W_LEN)] # Final Sequence\n    seg_sigs, r_peaks_ref = segmentSignals(full_rec_final,list(r_peaks_final)) # Final Signal Segmentation\n\n    return seg_sigs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Extracting List of the Elements with Two Sessions \ndir = '../input/ptb-dataset/ptb-diagnostic-ecg-database-1.0.0'\ntotal_index = 0\n#subjects_with_two = []\nsubjects = []\n\nfor item in np.sort(os.listdir(dir)):\n    #print('----------------------------------')\n    #print(item)\n    dir_sub = os.path.join(dir,item)\n    if(os.path.isdir(dir_sub)):\n        #ubjects.append(item)\n        #print(len(os.listdir(dir_sub))//3)\n        if(len(os.listdir(dir_sub))//3 >= 2):\n            subjects.append(item)\n            #total_index = total_index+1   \n            #print(item)\n        #    subjects_with_two.append(item)\n    #print('----------------------------------')\n\n#print(total_index)\n#print(subjects_with_two)\n\n#subjects = shuffle(subjects)[:100] # Shuffling and Taking 100 Subjects \n#print(subjects)\n\nprint(subjects)\nprint(len(subjects))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Creation of Numpy Arrays \nmain_dir = '../input/ptb-dataset/ptb-diagnostic-ecg-database-1.0.0'\n\nX_train = []\nX_dev = []\ny_train = []\ny_dev = []\n\ncurrent_index = 47\n\n#for person_index,person_folder in enumerate(list(np.sort(os.listdir(main_dir)))):\n \nfor person_folder in np.sort(subjects):\n    \n    #if(current_index <= 231): # Taking 80% of the subjects for training \n    \n    person_folder_path = os.path.join(main_dir,person_folder)\n    person_folder_items = (list(np.sort(os.listdir(person_folder_path))))\n\n    for file_idx in range(0,len(person_folder_items),3):\n        file_path_list = str((os.path.join(person_folder_path,person_folder_items[file_idx])))\n        file_num = file_idx//3\n\n        rec_path = ''\n        for item_index in range(0,(len(file_path_list)-4)):\n            rec_path = rec_path+str(file_path_list[item_index])\n\n        seg_signal_current = read_rec(rec_path) # Extracting Records\n\n        # Division across Time\n        #for k in range(len(seg_signal_current)):\n\n        #    if(k <= np.round(len(seg_signal_current)*0.5)):\n        #        X_train.append(seg_signal_current[k])\n        #        y_train.append(current_index)\n\n        #    else:\n        #        X_dev.append(seg_signal_current[k])\n        #        y_dev.append(current_index)\n\n        if(file_num == 0):\n            for k in range(len(seg_signal_current)):\n                X_train.append(seg_signal_current[k])\n                y_train.append(current_index)\n                \n        if(file_num == 1):\n            for k in range(len(seg_signal_current)):\n                X_train.append(seg_signal_current[k])\n                y_train.append(current_index)\n\n    current_index = current_index+1\n    print('Processed for Person - '+str(current_index))\n\n##### Creation of Numpy Arrays\nX_train_CD_train_PTB = np.array(X_train)\ny_train_CD_train_PTB = np.array(y_train)\n\nprint(np.array(X_train).shape)\nprint(np.array(y_train).shape)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## ECG-1D Dataset","metadata":{}},{"cell_type":"code","source":"####### Dataset Creation \n\n###### Constants\nFS = 360\nW_LEN = 256\nW_LEN_1_4 = 256 // 4\nW_LEN_3_4 = 3 * (256 // 4)\n\n###### Function to Read a Record\ndef read_rec(rec_path):\n\n    \"\"\" \n    Function to read record and return Segmented Signals\n\n    INPUTS:-\n    1) rec_path : Path of the Record\n\n    OUTPUTS:-\n    1) seg_sigs : Final Segmented Signals\n\n    \"\"\"\n    number_of_peaks = 2 # For extracting the required number of peaks                                    \n    full_rec = (wfdb.rdrecord(rec_path)).p_signal[:,1] # Entire Record\n\n    f = PchipInterpolator(np.arange(10000),full_rec) # Fitting Interpolation Function\n    x_samp = (np.arange(10000)*(500/360))[:7200] # Fixing Interpolation Input Values\n    full_rec_interp = f(x_samp)  # Intepolating Values \n    r_peaks_init = ecg.hamilton_segmenter(full_rec_interp,360)[0] # R-Peak Segmentation and input is the signal frequency of 500Hz in this case\n    final_peak_index = r_peaks_init[int(r_peaks_init.shape[0] - int((r_peaks_init.shape[0]%number_of_peaks)))-1]\n    r_peaks_final = r_peaks_init[:final_peak_index] # Final Number of R_Peaks\n    full_rec_final = full_rec_interp[:int(r_peaks_final[-1]+W_LEN)] # Final Sequence\n    seg_sigs, r_peaks_ref = segmentSignals(full_rec_final,list(r_peaks_final)) # Final Signal Segmentation\n\n    return seg_sigs # Returning the Ouput of the Signal Segmentation\n\n###### Function to Segment Signals\n\n##### Function\ndef segmentSignals(signal, r_peaks_annot, normalization=True, person_id= None, file_id=None):\n    \n    \"\"\"\n    Segments signals based on the detected R-Peak\n    Args:\n        signal (numpy array): input signal\n        r_peaks_annot (int []): r-peak locations.\n        normalization (bool, optional): apply z-normalization or not? . Defaults to True.\n        person_id ([type], optional): [description]. Defaults to None.\n        file_id ([type], optional): [description]. Defaults to None.\n    Returns:\n            [tuple(numpy array,numpy array)]: segmented signals and refined r-peaks\n    \"\"\"\n    def refine_rpeaks(signal, r_peaks):\n        \"\"\"\n        Refines the detected R-peaks. If the R-peak is slightly shifted, this assigns the \n        highest point R-peak.\n        Args:\n            signal (numpy array): input signal\n            r_peaks (int []): list of detected r-peaks\n        Returns:\n            [numpy array]: refined r-peaks\n        \"\"\"\n        r_peaks2 = np.array(r_peaks)            # make a copy\n        for i in range(len(r_peaks)):\n            r = r_peaks[i]          # current R-peak\n            small_segment = signal[max(0,r-100):min(len(signal),r+100)]         # consider the neighboring segment of R-peak\n            r_peaks2[i] = np.argmax(small_segment) - 100 + r_peaks[i]           # picking the highest point\n            r_peaks2[i] = min(r_peaks2[i],len(signal))                          # the detected R-peak shouldn't be outside the signal\n            r_peaks2[i] = max(r_peaks2[i],0)                                    # checking if it goes before zero    \n        return r_peaks2                     # returning the refined r-peak list\n    \n    segmented_signals = []                      # array containing the segmented beats\n    \n    r_peaks = np.array(r_peaks_annot)\n\n    r_peaks = refine_rpeaks(signal, r_peaks)\n    skip_len = 5 # Parameter to specify number of r_peaks in one signal\n    max_seq_len = 1280 # Parameter to specify maximum sequence length\n    \n    for r_curr in range(0,int(r_peaks.shape[0]-(skip_len-1)),skip_len):\n        if ((r_peaks[r_curr]-W_LEN_1_4)<0) or ((r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4)>=len(signal)):           # not enough signal to segment\n            continue\n        segmented_signal = np.array(signal[r_peaks[r_curr]-W_LEN_1_4:r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4])        # segmenting a heartbeat\n        segmented_signal = list(segmented_signal)\n        #print(segmented_signal.shape)\n        \n        if(len(segmented_signal) < 1280):\n            for m in range(int(1280-len(segmented_signal))): # Zero Padding\n                segmented_signal.append(0)\n        else:\n            segmented_signal = (segmented_signal[:int(max_seq_len)])\n            \n        segmented_signal = np.array(segmented_signal)\n        \n        if(segmented_signal.shape != (1280,1)):    \n            segmented_signal = np.reshape(segmented_signal,(1280,1))\n            \n        if (normalization):             # Z-score normalization\n            if abs(np.std(segmented_signal))<1e-6:          # flat line ECG, will cause zero division error\n                continue\n            segmented_signal = (segmented_signal - np.mean(segmented_signal)) / np.std(segmented_signal)            \n              \n        #if not np.isnan(segmented_signal).any():                    # checking for nan, this will never happen\n            segmented_signals.append(segmented_signal)\n\n    return segmented_signals,r_peaks           # returning the segmented signals and the refined r-peaks\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Numpy Array Creation \npath_to_dir = '../input/ecg1d/ecg-id-database-1.0.0'\ntotal_folders = 90\ncurrent_index = 0\n\nX_train = []\nX_dev = []\ny_train = []\ny_dev = []\n\n#for item in subjects_with_two:\nfor i in range(2,92):\n\n    if(i != 75):\n\n        print(i-1)\n        folder_path = os.path.join(path_to_dir,np.sort(os.listdir(path_to_dir))[i]) # Path Selection\n        #items_in_folder = int(len(folder_path)//3)\n        #current_storage_path = './5_Beat_Ecg_ECG1D'+'/person'+str(current_index)\n\n        #for j in os.listdir(item):\n\n        for j in range(2):\n\n            rec_path = folder_path+'/'+'rec'+'_'+str(j+1) # Path to Record\n            seg_signal_current = read_rec(rec_path)\n\n            if(j == 0):\n                for k in range(len(seg_signal_current)):\n                    #file_name_current = current_storage_path+'/'+str(j)+'_/'+str(k)\n                    #np.savez_compressed(file_name_current,seg_signal_current[k])\n                    X_train.append(seg_signal_current[k])\n                    y_train.append(current_index)\n\n            else:\n                for k in range(len(seg_signal_current)):\n                    #file_name_current = current_storage_path+'/'+str(j)+'_/'+str(k)\n                    #np.savez_compressed(file_name_current,seg_signal_current[k])\n                    X_dev.append(seg_signal_current[k])\n                    y_dev.append(current_index)\n\n        current_index = current_index+1\n\n###### Shuffling Numpy Arrays\nX_train,y_train = shuffle(X_train,y_train)\nX_dev,y_dev = shuffle(X_dev,y_dev)\n\n###### Checking Shape of the Arrays\nprint(np.array(X_train).shape)\nprint(np.array(y_train).shape)\nprint(np.array(X_dev).shape)\nprint(np.array(y_dev).shape)\n\nprint(np.max(y_train))\nprint(np.min(y_dev))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"##### Plotting and Testing the Dataset\n\nfor i in range(100,110):\n    print(y_train[i])\n    plt.plot(np.arange(1280),X_train[i])\n    plt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Dataset Creation and Loading ","metadata":{}},{"cell_type":"markdown","source":"### Training Data","metadata":{}},{"cell_type":"code","source":"###### Amalgamating Datasets \nX_train = np.array(list(X_train_CD_train_MITBIH)+list(X_train_CD_train_PTB))\ny_train = np.array(list(y_train_CD_train_MITBIH)+list(y_train_CD_train_PTB))\n\nX_train,y_train = shuffle(X_train,y_train)\n\nprint(X_train.shape)\nprint(y_train.shape)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T08:14:41.054154Z","iopub.execute_input":"2021-08-02T08:14:41.054569Z","iopub.status.idle":"2021-08-02T08:14:42.868310Z","shell.execute_reply.started":"2021-08-02T08:14:41.054535Z","shell.execute_reply":"2021-08-02T08:14:42.867188Z"},"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"(28878, 1280, 1)\n(28878,)\n","output_type":"stream"}]},{"cell_type":"code","source":"###### Saving Numpy Arrays\nnp.savez_compressed('./X_train_CD_MPE.npz',np.array(X_train))\nnp.savez_compressed('./y_train_CD_MPE.npz',np.array(y_train))","metadata":{"execution":{"iopub.status.busy":"2021-08-02T08:14:47.861714Z","iopub.execute_input":"2021-08-02T08:14:47.862419Z","iopub.status.idle":"2021-08-02T08:16:58.866984Z","shell.execute_reply.started":"2021-08-02T08:14:47.862366Z","shell.execute_reply":"2021-08-02T08:16:58.865872Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"##### Loading Dataset - Training Dataset\nX_train = np.array(np.load('./X_train_CD_MPE.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\ny_train = np.array(np.load('./y_train_CD_MPE.npz',allow_pickle=True)['arr_0'],dtype=np.float16)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T08:20:28.546810Z","iopub.execute_input":"2021-08-02T08:20:28.547305Z","iopub.status.idle":"2021-08-02T08:21:26.416154Z","shell.execute_reply.started":"2021-08-02T08:20:28.547275Z","shell.execute_reply":"2021-08-02T08:21:26.415396Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"##### Converting Labels to Categorical Format\ny_train_ohot = tf.keras.utils.to_categorical(y_train)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T08:21:26.417580Z","iopub.execute_input":"2021-08-02T08:21:26.418144Z","iopub.status.idle":"2021-08-02T08:21:26.425947Z","shell.execute_reply.started":"2021-08-02T08:21:26.418101Z","shell.execute_reply":"2021-08-02T08:21:26.425231Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"##### Plotting and Testing the Dataset\n\nfor i in range(1000,1010):\n    print(y_train[i])\n    plt.plot(np.arange(1280),X_train[i])\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2021-08-02T08:21:26.427752Z","iopub.execute_input":"2021-08-02T08:21:26.428344Z","iopub.status.idle":"2021-08-02T08:21:27.798582Z","shell.execute_reply.started":"2021-08-02T08:21:26.428301Z","shell.execute_reply":"2021-08-02T08:21:27.797501Z"},"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"1.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"1.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"46.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"31.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"91.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"112.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"21.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"15.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"13.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"138.0\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"### Testing Data","metadata":{}},{"cell_type":"code","source":"###### Saving Numpy Arrays\nnp.savez_compressed('./X_train_CD_MPE_test.npz',np.array(X_train))\nnp.savez_compressed('./y_train_CD_MPE_test.npz',np.array(y_train))\nnp.savez_compressed('./X_dev_CD_MPE_test.npz',np.array(X_dev))\nnp.savez_compressed('./y_dev_CD_MPE_test.npz',np.array(y_dev))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"##### Loading Dataset - Testing Dataset\nX_train = np.array(np.load('../input/cd-mpe/X_train_CD_MPE_test.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\nX_dev = np.array(np.load('../input/cd-mpe/X_dev_CD_MPE_test.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\ny_train = np.load('../input/cd-mpe/y_train_CD_MPE_test.npz',allow_pickle=True)['arr_0']\ny_dev = np.load('../input/cd-mpe/y_dev_CD_MPE_test.npz',allow_pickle=True)['arr_0']","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:36:32.503690Z","iopub.execute_input":"2021-08-02T10:36:32.504206Z","iopub.status.idle":"2021-08-02T10:36:32.864260Z","shell.execute_reply.started":"2021-08-02T10:36:32.504172Z","shell.execute_reply":"2021-08-02T10:36:32.863260Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"##### Converting Labels to Categorical Format\ny_train_ohot = tf.keras.utils.to_categorical(y_train)\ny_dev_ohot = tf.keras.utils.to_categorical(y_dev)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:36:34.861832Z","iopub.execute_input":"2021-08-02T10:36:34.862201Z","iopub.status.idle":"2021-08-02T10:36:34.867981Z","shell.execute_reply.started":"2021-08-02T10:36:34.862168Z","shell.execute_reply":"2021-08-02T10:36:34.866567Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":"# Model Making","metadata":{}},{"cell_type":"markdown","source":"## Self-Calibrated Convolution","metadata":{}},{"cell_type":"code","source":"###### Model Development : Self-Calibrated \n\n##### Defining Self-Calibrated Block\n\nrate_regularizer = 1e-5\nclass self_cal_Conv1D(tf.keras.layers.Layer):\n\n    \"\"\" \n    This is inherited class from keras.layers and shall be instatition of self-calibrated convolutions\n    \"\"\"\n    \n    def __init__(self,num_filters,kernel_size,num_features):\n    \n        #### Defining Essentials\n        super().__init__()\n        self.num_filters = num_filters\n        self.kernel_size = kernel_size\n        self.num_features = num_features # Number of Channels in Input\n\n        #### Defining Layers\n        self.conv2 = tf.keras.layers.Conv1D(self.num_features/2,self.kernel_size,padding='same',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32',activation='relu')\n        self.conv3 = tf.keras.layers.Conv1D(self.num_features/2,self.kernel_size,padding='same',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32',activation='relu')\n        self.conv4 = tf.keras.layers.Conv1D(self.num_filters/2,self.kernel_size,padding='same',activation='relu',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32')\n        self.conv1 = tf.keras.layers.Conv1D(self.num_filters/2,self.kernel_size,padding='same',activation='relu',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32')\n        self.upsample = tf.keras.layers.Conv1DTranspose(filters=int(self.num_features/2),kernel_size=5,strides=5)\n        #self.attention_layer = tf.keras.layers.Attention()\n        #self.lstm = tf.keras.layers.LSTM(int(self.num_features/2),return_sequences=True)\n        #self.layernorm = tf.keras.layers.LayerNormalization()\n    \n    def get_config(self):\n\n        config = super().get_config().copy()\n        config.update({\n            'num_filters': self.num_filters,\n            'kernel_size': self.kernel_size,\n            'num_features': self.num_features\n        })\n        return config\n    \n    \n    def call(self,X):\n       \n        \"\"\"\n          INPUTS : 1) X - Input Tensor of shape (batch_size,sequence_length,num_features)\n          OUTPUTS : 1) X - Output Tensor of shape (batch_size,sequence_length,num_features)\n        \"\"\"\n        \n        #### Dimension Extraction\n        b_s = (X.shape)[0] \n        seq_len = (X.shape)[1]\n        num_features = (X.shape)[2]\n        \n        #### Channel-Wise Division\n        X_attention = X[:,:,0:int(self.num_features/2)]\n        X_global = X[:,:,int(self.num_features/2):]\n        \n        #### Self Calibration Block\n\n        ### Local Feature Detection\n\n        ## Down-Sampling\n        #x1 = X_attention[:,0:int(seq_len/5),:]\n        #x2 = X_attention[:,int(seq_len/5):int(seq_len*(2/5)),:]\n        #x3 = X_attention[:,int(seq_len*(2/5)):int(seq_len*(3/5)),:]\n        #x4 = X_attention[:,int(seq_len*(3/5)):int(seq_len*(4/5)),:]\n        #x5 = X_attention[:,int(seq_len*(4/5)):seq_len,:]\n        x_down_sampled = tf.keras.layers.AveragePooling1D(pool_size=5,strides=5)(X_attention)\n        \n        ## Convoluting Down Sampled Sequence \n        #x1 = self.conv2(x1)\n        #x2 = self.conv2(x2)\n        #x3 = self.conv2(x3)\n        #x4 = self.conv2(x4)\n        #x5 = self.conv2(x5)\n        x_down_conv = self.conv2(x_down_sampled)\n        #x_down_feature = self.attention_layer([x_down_sampled,x_down_sampled])\n        #x_down_feature = self.lstm(x_down_sampled)\n        #x_down_feature = self.layernorm(x_down_feature)\n        \n        ## Up-Sampling\n        x_down_upsampled = self.upsample(x_down_conv)   \n        #X_local_upsampled = tf.keras.layers.concatenate([x1,x2,x3,x4,x5],axis=1)\n\n        ## Local-CAM\n        X_local = X_attention + x_down_upsampled  #X_local_upsampled\n\n        ## Local Importance \n        X_2 = tf.keras.activations.sigmoid(X_local)\n\n        ### Self-Calibration\n\n        ## Global Convolution\n        X_3 = self.conv3(X_attention)\n\n        ## Attention Determination\n        X_attention = tf.math.multiply(X_2,X_3)\n\n        #### Self-Calibration Feature Extraction\n        X_4 = self.conv4(X_attention)\n\n        #### Normal Feature Extraction\n        X_1 = self.conv1(X_global)\n\n        #### Concatenating and Returning Output\n        return (tf.keras.layers.concatenate([X_1,X_4],axis=2))","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:36:36.553809Z","iopub.execute_input":"2021-08-02T10:36:36.554236Z","iopub.status.idle":"2021-08-02T10:36:36.748633Z","shell.execute_reply.started":"2021-08-02T10:36:36.554196Z","shell.execute_reply":"2021-08-02T10:36:36.746448Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"markdown","source":"## Transformer","metadata":{}},{"cell_type":"code","source":"def get_angles(pos, i, d_model):\n    angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))\n    return pos * angle_rates\n\ndef positional_encoding(position, d_model):\n    angle_rads = get_angles(np.arange(position)[:, np.newaxis],\n                          np.arange(d_model)[np.newaxis, :],\n                          d_model)\n  \n  # apply sin to even indices in the array; 2i\n    angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n  \n  # apply cos to odd indices in the array; 2i+1\n    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n    \n    pos_encoding = angle_rads[np.newaxis, ...]\n    \n    return tf.cast(pos_encoding, dtype=tf.float32)\n\ndef create_padding_mask(seq):\n    seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\n  \n    # add extra dimensions to add the padding\n    # to the attention logits. \n    return seq[:, tf.newaxis, tf.newaxis, :]  # (batch_size, 1, 1, seq_len)\n\ndef scaled_dot_product_attention(q, k, v, mask):\n    \"\"\"Calculate the attention weights.\n    q, k, v must have matching leading dimensions.\n    k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.\n    The mask has different shapes depending on its type(padding or look ahead) \n    but it must be broadcastable for addition.\n\n    Args:\n    q: query shape == (..., seq_len_q, depth)\n    k: key shape == (..., seq_len_k, depth)\n    v: value shape == (..., seq_len_v, depth_v)\n    mask: Float tensor with shape broadcastable \n          to (..., seq_len_q, seq_len_k). Defaults to None.\n\n    Returns:\n    output, attention_weights\n    \"\"\"\n\n    matmul_qk = tf.matmul(q, k, transpose_b=True)  # (..., seq_len_q, seq_len_k)\n  \n    # scale matmul_qk\n    dk = tf.cast(tf.shape(k)[-1], tf.float32)\n    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n\n    # add the mask to the scaled tensor.\n    if mask is not None:\n        scaled_attention_logits += (mask * -1e9)  \n\n    # softmax is normalized on the last axis (seq_len_k) so that the scores\n    # add up to 1.\n    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # (..., seq_len_q, seq_len_k)\n\n    output = tf.matmul(attention_weights, v)  # (..., seq_len_q, depth_v)\n\n    return output, attention_weights\n\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    \n    def __init__(self, d_model, num_heads):\n        super(MultiHeadAttention, self).__init__()\n        self.num_heads = num_heads\n        self.d_model = d_model\n\n        assert d_model % self.num_heads == 0\n\n        self.depth = d_model // self.num_heads\n\n        self.wq = tf.keras.layers.Dense(d_model)\n        self.wk = tf.keras.layers.Dense(d_model)\n        self.wv = tf.keras.layers.Dense(d_model)\n\n        self.dense = tf.keras.layers.Dense(d_model)\n\n    def get_config(self):\n        config = super(MultiHeadAttention, self).get_config().copy()\n        config.update({\n            'd_model': self.d_model,\n            'num_heads':self.num_heads\n        })\n        \n    def split_heads(self, x, batch_size):\n        \n        \"\"\"Split the last dimension into (num_heads, depth).\n        Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)\n        \"\"\"\n        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))\n        return tf.transpose(x, perm=[0, 2, 1, 3])\n    \n    def call(self, v, k, q, mask):\n        batch_size = tf.shape(q)[0]\n\n        q = self.wq(q)  # (batch_size, seq_len, d_model)\n        k = self.wk(k)  # (batch_size, seq_len, d_model)\n        v = self.wv(v)  # (batch_size, seq_len, d_model)\n\n        q = self.split_heads(q, batch_size)  # (batch_size, num_heads, seq_len_q, depth)\n        k = self.split_heads(k, batch_size)  # (batch_size, num_heads, seq_len_k, depth)\n        v = self.split_heads(v, batch_size)  # (batch_size, num_heads, seq_len_v, depth)\n\n        # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)\n        # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)\n        scaled_attention, attention_weights = scaled_dot_product_attention(\n            q, k, v, mask)\n\n        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])  # (batch_size, seq_len_q, num_heads, depth)\n\n        concat_attention = tf.reshape(scaled_attention, \n                                      (batch_size, -1, self.d_model))  # (batch_size, seq_len_q, d_model)\n\n        output = self.dense(concat_attention)  # (batch_size, seq_len_q, d_model)\n\n        return output, attention_weights\n\ndef point_wise_feed_forward_network(d_model, dff):\n    return tf.keras.Sequential([\n      tf.keras.layers.Dense(dff, activation='relu'),  # (batch_size, seq_len, dff)\n      tf.keras.layers.Dense(d_model)  # (batch_size, seq_len, d_model)\n  ])\n\nclass Encoder(tf.keras.layers.Layer):\n    def __init__(self, num_layers, d_model, num_heads, dff,\n               maximum_position_encoding, rate=0.1):\n        super(Encoder, self).__init__()\n\n        self.d_model = d_model\n        self.num_layers = num_layers\n        self.num_heads = num_heads\n        self.dff = dff\n        self.maximum_position_encoding = maximum_position_encoding\n        self.rate = rate\n\n        #self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)\n        self.pos_encoding = positional_encoding(maximum_position_encoding, \n                                                self.d_model)\n\n\n        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) \n                           for _ in range(num_layers)]\n\n        self.dropout = tf.keras.layers.Dropout(rate)\n        \n    def get_config(self):\n        config = super(Encoder, self).get_config().copy()\n        config.update({\n            'num_layers': self.num_layers,\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'maximum_position_encoding':self.maximum_position_encoding,\n            'rate':self.rate  \n        })\n        \n    def call(self, x, training, mask):\n\n        seq_len = tf.shape(x)[1]\n\n        # adding embedding and position encoding.\n        #x = self.embedding(x)  # (batch_size, input_seq_len, d_model)\n        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n        x += self.pos_encoding[:, :seq_len, :]\n\n        x = self.dropout(x, training=training)         \n\n        for i in range(self.num_layers):\n            x = self.enc_layers[i](x, training, mask)\n\n        return x  # (batch_size, input_seq_len, d_model)\n\nclass EncoderLayer(tf.keras.layers.Layer):\n    def __init__(self, d_model, num_heads, dff, rate=0.1):\n        super(EncoderLayer, self).__init__()\n        \n        self.d_model = d_model\n        self.num_heads = num_heads\n        self.dff = dff\n        self.rate = rate\n\n        self.mha = MultiHeadAttention(d_model, num_heads)\n        self.ffn = point_wise_feed_forward_network(d_model, dff)\n\n        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n\n        self.dropout1 = tf.keras.layers.Dropout(rate)\n        self.dropout2 = tf.keras.layers.Dropout(rate)\n        \n    def get_config(self):\n        config = super(EncoderLayer, self).get_config().copy()\n        config.update({\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'rate':self.rate  \n        })\n        \n    def call(self, x, training, mask):\n\n        attn_output, _ = self.mha(x, x, x, mask)  # (batch_size, input_seq_len, d_model)\n        attn_output = self.dropout1(attn_output, training=training)\n        out1 = self.layernorm1(x + attn_output)  # (batch_size, input_seq_len, d_model)\n\n        ffn_output = self.ffn(out1)  # (batch_size, input_seq_len, d_model)\n        ffn_output = self.dropout2(ffn_output, training=training)\n        out2 = self.layernorm2(out1 + ffn_output)  # (batch_size, input_seq_len, d_model)\n    \n        return out2\n    \nclass Transformer(tf.keras.Model):\n    def __init__(self, num_layers, d_model, num_heads, dff, \n                 pe_input, rate=0.1):\n        super(Transformer, self).__init__()\n        \n        self.num_layers = num_layers\n        self.d_model = d_model\n        self.num_heads = num_heads\n        self.dff = dff\n        self.pe_input = pe_input\n        self.rate = rate\n        \n        self.encoder = Encoder(num_layers, d_model, num_heads, dff, \n                                pe_input, rate)\n        \n    def get_config(self):\n        config = super(Transformer,self).get_config().copy()\n        config.update({\n            'num_layers': self.num_layers,\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'pe_input':self.pe_input,\n            'rate':self.rate  \n        })\n    \n    def call(self, inp, training, enc_padding_mask):\n        return self.encoder(inp, training, enc_padding_mask)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:36:42.589595Z","iopub.execute_input":"2021-08-02T10:36:42.589953Z","iopub.status.idle":"2021-08-02T10:36:42.632337Z","shell.execute_reply.started":"2021-08-02T10:36:42.589922Z","shell.execute_reply":"2021-08-02T10:36:42.631501Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":"## ArcFace Loss","metadata":{}},{"cell_type":"code","source":"class ArcFace(tf.keras.layers.Layer):\n    \n    def __init__(self, n_classes, s, m,regularizer):\n        super().__init__()\n        self.n_classes = n_classes\n        self.s = s\n        self.m = m\n        self.regularizer = tf.keras.regularizers.get(regularizer)\n\n    def get_config(self):\n\n        config = super().get_config().copy()\n        config.update({\n            'n_classes': self.n_classes,\n            's': self.s,\n            'm': self.m,\n            'regularizer': self.regularizer\n        })\n        return config\n\n    def build(self, input_shape):\n        super(ArcFace, self).build(input_shape[0])\n        self.W = self.add_weight(name='W',\n                                shape=(input_shape[0][-1], self.n_classes),\n                                initializer='glorot_uniform',\n                                trainable=True\n                                )\n\n    def call(self, inputs):\n        x, y = inputs\n        c = tf.keras.backend.shape(x)[-1]\n        # normalize feature\n        x = tf.nn.l2_normalize(x, axis=1)\n        # normalize weights\n        W = tf.nn.l2_normalize(self.W, axis=0)\n        # dot product\n        logits = x @ W\n        # add margin\n        # clip logits to prevent zero division when backward\n        theta = tf.acos(tf.keras.backend.clip(logits, -1.0 + tf.keras.backend.epsilon(), 1.0 - tf.keras.backend.epsilon()))\n        target_logits = tf.cos(theta + self.m)\n        # sin = tf.sqrt(1 - logits**2)\n        # cos_m = tf.cos(logits)\n        # sin_m = tf.sin(logits)\n        # target_logits = logits * cos_m - sin * sin_m\n        #\n        logits = logits * (1 - y) + target_logits * y\n        # feature re-scale\n        logits *= self.s\n        out = tf.nn.softmax(logits)    \n        return out\n\n    def compute_output_shape(self, input_shape):\n        return (None, self.n_classes)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:36:49.750145Z","iopub.execute_input":"2021-08-02T10:36:49.750514Z","iopub.status.idle":"2021-08-02T10:36:49.764560Z","shell.execute_reply.started":"2021-08-02T10:36:49.750484Z","shell.execute_reply":"2021-08-02T10:36:49.762993Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"markdown","source":"# Model Training","metadata":{}},{"cell_type":"code","source":"####### Phase-1 Models\n###### Defining Architecture\n\nwith tpu_strategy.scope():\n\n    ##### SC_Module \n\n    #### Defining Hyperparameters\n    num_layers = 2\n    d_model = 512\n    num_heads = 8\n    dff = 1024\n    max_seq_len = 1280 #X_train.shape[1]\n    pe_input = 320\n    rate = 0.5\n    num_features = 1\n    num_classes = 89\n\n    #### Defining Layers\n    Input_layer = tf.keras.layers.Input(shape=(max_seq_len,num_features))\n    self_conv1 = self_cal_Conv1D(128,15,128)\n    self_conv2 = self_cal_Conv1D(128,20,128) # Newly Added\n    self_conv3 = self_cal_Conv1D(256,15,128)\n    self_conv4 = self_cal_Conv1D(256,20,256) # Newly Added\n    self_conv5 = self_cal_Conv1D(512,15,256)\n    self_conv6 = self_cal_Conv1D(512,20,512) # Newly Added\n    self_conv7 = self_cal_Conv1D(1024,15,512)\n    self_conv8 = self_cal_Conv1D(1024,20,1024) # Newly Added\n    conv_initial = tf.keras.layers.Conv1D(32,15,padding='same',activation='relu')\n    conv_second = tf.keras.layers.Conv1D(64,15,padding='same',activation='relu')\n    conv_third = tf.keras.layers.Conv1D(128,15,padding='same',activation='relu')\n    #lstm1 = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(128,activation='tanh',return_sequences=True),merge_mode='ave')\n    transform_1 = tf.keras.layers.Conv1D(128,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_2 = tf.keras.layers.Conv1D(256,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_3 = tf.keras.layers.Conv1D(512,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_4 = tf.keras.layers.Conv1D(1024,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transformer = Transformer(num_layers,d_model,num_heads,dff,pe_input,rate)\n    gap_layer = tf.keras.layers.GlobalAveragePooling1D()\n    arc_logit_layer = ArcFace(89,30.0,0.3,tf.keras.regularizers.l2(1e-4))\n\n    #### Defining Architecture\n    ### Input Layer\n    Inputs = Input_layer\n    Input_Labels = tf.keras.layers.Input(shape=(num_classes,))\n\n    ### Initial Convolutional Layers\n    conv_initial = conv_initial(Inputs)\n    #conv_initial = tf.keras.layers.LayerNormalization()(conv_initial)\n    #conv_initial = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_initial)     \n    #conv_initial = tf.keras.layers.Add()([conv_initial,Inputs])\n    \n    conv_second = conv_second(conv_initial)\n    #conv_second = tf.keras.layers.LayerNormalization()(conv_second)\n    #conv_second = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_second)\n    #conv_second = tf.keras.layers.Add()([conv_second,conv_initial])\n    #conv_second = tf.keras.layers.concatenate(axis=2)([conv_initial,conv_second])\n    \n    conv_third = conv_third(conv_second)\n    #conv_third = tf.keras.layers.LayerNormalization()(conv_third)\n    #conv_third = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_third)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(Inputs)\n    #conv_third = tf.keras.layers.Add()([conv_third,conv_second])\n    #conv_third = tf.keras.layers.concatenate(axis=2)([conv_initial,conv_second,conv_third])\n    #conv_third = lstm1(conv_second)\n    #conv_third = tf.keras.layers.Attention()([conv_third,conv_third])\n    \n    ### 1st Residual Block\n    transform_1 = transform_1(conv_third)\n    conv1 = self_conv1(conv_third)\n    #conv1 = tf.keras.layers.AlphaDropout(rate=0.2)(conv1)\n    conv2 = self_conv2(conv1)\n    #conv2 = tf.keras.layers.AlphaDropout(rate=0.2)(conv2)\n    conv2 = tf.keras.layers.Add()([conv2,transform_1])\n    #conv2 = tf.keras.layers.LayerNormalization()(conv2)\n    conv2 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv2)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(mask)    \n\n    ### 2nd Residual Block\n    #conv_third = tf.keras.layers.Attention()([conv_third,conv_third])\n    transform_2 = transform_2(conv2)\n    conv3 = self_conv3(conv2)\n    #conv3 = tf.keras.layers.AlphaDropout(rate=0.2)(conv3)\n    conv4 = self_conv4(conv3)\n    #conv4 = tf.keras.layers.AlphaDropout(rate=0.2)(conv4)\n    conv4 = tf.keras.layers.Add()([conv4,transform_2])\n    #conv4 = tf.keras.layers.LayerNormalization()(conv4)\n    conv4 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv4)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(mask)\n\n    ### 3rd Residual Block\n    transform_3 = transform_3(conv4)\n    conv5 = self_conv5(conv4)\n    #conv5 = tf.keras.layers.AlphaDropout(rate=0.2)(conv5)\n    conv6 = self_conv6(conv5)\n    #conv6 = tf.keras.layers.AlphaDropout(rate=0.2)(conv6)\n    conv6 = tf.keras.layers.Add()([conv6,transform_3])\n    #conv6 = tf.keras.layers.LayerNormalization()(conv6)\n    #conv6 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv6)\n\n    ### 4th Residual Block\n    #transform_4 = transform_4(conv6)\n    #conv7 = self_conv7(conv6)\n    #conv8 = self_conv8(conv7)\n    #conv8 = tf.keras.layers.Add()([conv8,transform_4])\n\n    ### Transformer\n    ## Wide-Head Attention Model\n    #tx_embedding = tf.keras.layers.Lambda(PE_Layer)(Inputs)\n    #tx_embedding = tf.keras.layers.Dropout(rate)(tx_embedding,training=True)\n    #mask_reshaped = tf.keras.layers.Reshape((max_seq_len,))(Inputs)\n    #encoder_op1 = encoder_block1(tx_embedding,mask_reshaped)\n    #encoder_op2 = encoder_block2(encoder_op1,mask_reshaped)\n\n    ## Narrow-Head Attention Model\n    #mask_reshaped = tf.keras.layers.Reshape((160,))(mask)\n    embeddings =  transformer(inp=conv6,enc_padding_mask=None)\n    #embeddings = transformer(inp=conv6,enc_padding_mask=create_padding_mask(mask))\n    #residual_embeddings = tf.keras.layers.Add()([conv6,embeddings])\n\n    ### Output Layers\n    ## Initial Layers\n    gap_op = gap_layer(embeddings)\n    dense1 = tf.keras.layers.Dense(256,activation='relu')(gap_op)\n    dropout1 = tf.keras.layers.Dropout(rate)(dense1)\n    \n    ## ArcFace Output Network\n    dense2 = tf.keras.layers.Dense(256,kernel_initializer='he_normal',\n                kernel_regularizer=tf.keras.regularizers.l2(1e-4))(dropout1)\n    ##dense2 = tf.keras.layers.BatchNormalization()(dense2)\n    dense3 = arc_logit_layer(([dense2,Input_Labels]))\n    \n    ## Softmax Output Network\n    #dense2 = tf.keras.layers.Dense(256,activation='relu')(dropout1)\n    ###dropout2 = tf.keras.layers.Dropout(rate)(dense2) # Not to be included\n    #dense3 = tf.keras.layers.Dense(35,activation='softmax')(dense2)\n\n    #### Compiling Architecture            \n    ### ArcFace Model Compilation\n    model = tf.keras.models.Model(inputs=[Inputs,Input_Labels],outputs=dense3)\n    model.load_weights('../input/cd-mpe/CD_MPE.h5')\n    model.compile(tf.keras.optimizers.Adam(lr=1e-4,clipnorm=1.0),loss='categorical_crossentropy',metrics=['accuracy'])\n    ### Softmax Model Compilation\n    #model = tf.keras.models.Model(inputs=Inputs,outputs=dense3)\n\nmodel.summary()      \ntf.keras.utils.plot_model(model)\n##### Model Training \n\n#### Model Checkpointing\n#! mkdir './Models'\n#filepath= \"/content/Models/saved-model-{epoch:02d}-{val_accuracy:.2f}.h5\"\n#checkpoint = tf.keras.callbacks.ModelCheckpoint(filepath,monitor='val_accuracy',save_best_only=False,mode='max')\nfilepath = './CD_MPE.h5'\ncheckpoint = tf.keras.callbacks.ModelCheckpoint(filepath,monitor='val_accuracy',save_best_only=True,mode='max',save_weights_only=True)\n\n#### Custom Learning Rate Schedule\n#def build_lrfn(lr_start=1e-4, lr_max=1e-3, \n#               lr_min=1e-6, lr_rampup_epochs=5, \n#               lr_sustain_epochs=0, lr_exp_decay=.87):\n#    lr_max = lr_max * tpu_strategy.num_replicas_in_sync\n\n#    def lrfn(epoch):\n#        if epoch < lr_rampup_epochs:\n#            lr = (lr_max - lr_start) / lr_rampup_epochs * epoch + lr_start\n#        elif epoch < lr_rampup_epochs + lr_sustain_epochs:\n#            lr = lr_max\n#        else:\n#            lr = (lr_max - lr_min) * lr_exp_decay**(epoch - lr_rampup_epochs - lr_sustain_epochs) + lr_min#\n#        return lr\n#    \n#    return lrfn\n\n#lrfn = build_lrfn()\n#lr_callback = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=1)\n#callback_list = [checkpoint,  lr_callback]\n\n#### Model Training\n#### Model Training\n### ArcFace Training\n#history = model.fit((X_train,y_train_ohot),y_train_ohot,epochs=500,batch_size=128,\n#                validation_split=0.1,validation_batch_size=128,\n#               callbacks=checkpoint)\n\n### Softmax Training \n#history = model.fit(X_train,y_train_ohot,epochs=250,batch_size=128,\n#                validation_data=(X_dev,y_dev_ohot),validation_batch_size=128,\n#                callbacks=checkpoint)\n\n\n##### Plotting Metrics  \n#### Accuracy and Loss Plots \n\n### Accuracy\n#plt.plot(history.history['accuracy'])\n#plt.plot(history.history['val_accuracy'])\n#plt.title('Model Accuracy')\n#plt.ylabel('Accuracy')\n#plt.xlabel('Epoch')  \n#plt.legend(['Train', 'Validation'], loc='best')\n#plt.show()\n\n### Loss     \n#plt.plot(history.history['loss'])  \n#plt.plot(history.history['val_loss'])\n#plt.title('Model Loss')  \n#plt.ylabel('Loss')         \n#plt.xlabel('epoch')\n#plt.legend(['Train', 'Validation'], loc='best')   \n#plt.show()      \n\n##### Saving Model            \n#model.save_weights('ECG_SCNRNet.h5' )","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:38:14.903622Z","iopub.execute_input":"2021-08-02T10:38:14.903957Z","iopub.status.idle":"2021-08-02T10:38:23.291906Z","shell.execute_reply.started":"2021-08-02T10:38:14.903928Z","shell.execute_reply":"2021-08-02T10:38:23.290664Z"},"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"Model: \"model\"\n__________________________________________________________________________________________________\nLayer (type)                    Output Shape         Param #     Connected to                     \n==================================================================================================\ninput_1 (InputLayer)            [(None, 1280, 1)]    0                                            \n__________________________________________________________________________________________________\nconv1d_32 (Conv1D)              (None, 1280, 32)     512         input_1[0][0]                    \n__________________________________________________________________________________________________\nconv1d_33 (Conv1D)              (None, 1280, 64)     30784       conv1d_32[0][0]                  \n__________________________________________________________________________________________________\nconv1d_34 (Conv1D)              (None, 1280, 128)    123008      conv1d_33[0][0]                  \n__________________________________________________________________________________________________\nself_cal__conv1d (self_cal_Conv (None, 1280, 128)    266560      conv1d_34[0][0]                  \n__________________________________________________________________________________________________\nself_cal__conv1d_1 (self_cal_Co (None, 1280, 128)    348480      self_cal__conv1d[0][0]           \n__________________________________________________________________________________________________\nconv1d_35 (Conv1D)              (None, 1280, 128)    49280       conv1d_34[0][0]                  \n__________________________________________________________________________________________________\nadd (Add)                       (None, 1280, 128)    0           self_cal__conv1d_1[0][0]         \n                                                                 conv1d_35[0][0]                  \n__________________________________________________________________________________________________\nmax_pooling1d (MaxPooling1D)    (None, 640, 128)     0           add[0][0]                        \n__________________________________________________________________________________________________\nself_cal__conv1d_2 (self_cal_Co (None, 640, 256)     389568      max_pooling1d[0][0]              \n__________________________________________________________________________________________________\nself_cal__conv1d_3 (self_cal_Co (None, 640, 256)     1393280     self_cal__conv1d_2[0][0]         \n__________________________________________________________________________________________________\nconv1d_36 (Conv1D)              (None, 640, 256)     98560       max_pooling1d[0][0]              \n__________________________________________________________________________________________________\nadd_1 (Add)                     (None, 640, 256)     0           self_cal__conv1d_3[0][0]         \n                                                                 conv1d_36[0][0]                  \n__________________________________________________________________________________________________\nmax_pooling1d_1 (MaxPooling1D)  (None, 320, 256)     0           add_1[0][0]                      \n__________________________________________________________________________________________________\nself_cal__conv1d_4 (self_cal_Co (None, 320, 512)     1557376     max_pooling1d_1[0][0]            \n__________________________________________________________________________________________________\nself_cal__conv1d_5 (self_cal_Co (None, 320, 512)     5571840     self_cal__conv1d_4[0][0]         \n__________________________________________________________________________________________________\nconv1d_37 (Conv1D)              (None, 320, 512)     393728      max_pooling1d_1[0][0]            \n__________________________________________________________________________________________________\nadd_2 (Add)                     (None, 320, 512)     0           self_cal__conv1d_5[0][0]         \n                                                                 conv1d_37[0][0]                  \n__________________________________________________________________________________________________\ntransformer (Transformer)       (None, 320, 512)     4205568     add_2[0][0]                      \n__________________________________________________________________________________________________\nglobal_average_pooling1d (Globa (None, 512)          0           transformer[0][0]                \n__________________________________________________________________________________________________\ndense_12 (Dense)                (None, 256)          131328      global_average_pooling1d[0][0]   \n__________________________________________________________________________________________________\ndropout_5 (Dropout)             (None, 256)          0           dense_12[0][0]                   \n__________________________________________________________________________________________________\ndense_13 (Dense)                (None, 256)          65792       dropout_5[0][0]                  \n__________________________________________________________________________________________________\ninput_2 (InputLayer)            [(None, 89)]         0                                            \n__________________________________________________________________________________________________\narc_face (ArcFace)              (None, 89)           22784       dense_13[0][0]                   \n                                                                 input_2[0][0]                    \n==================================================================================================\nTotal params: 14,648,448\nTrainable params: 14,648,448\nNon-trainable params: 0\n__________________________________________________________________________________________________\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Model Testing","metadata":{}},{"cell_type":"markdown","source":"## KNN based ArcFace Loss Testing","metadata":{}},{"cell_type":"code","source":"###### Testing Model - ArcFace Style                \nwith tpu_strategy.scope():     \n\n    def normalisation_layer(x):   \n        return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))\n\n    #X_dev_flipped = tf.image.flip_up_down(X_dev)  \n    #x_train_flipped = tf.image.flip_up_down(X_train_final)\n\n    predictive_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-3].output)\n    predictive_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\nwith tpu_strategy.scope():\n    y_in = tf.keras.layers.Input((89,))\n\n    Input_Layer = tf.keras.layers.Input((1280,1))\n    op_1 = predictive_model([Input_Layer,y_in])\n\n    ##Input_Layer_Flipped = tf.keras.layers.Input((224,224,3))\n    ##op_2 = predictive_model([Input_Layer_Flipped,y_in]) \n    ##final_op = tf.keras.layers.Concatenate(axis=1)(op_1)\n\n    final_norm_op = tf.keras.layers.Lambda(normalisation_layer)(op_1)\n\n    testing_model = tf.keras.models.Model(inputs=[Input_Layer,y_in],outputs=final_norm_op)\n    testing_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\n##### Nearest Neighbor Classification\nfrom sklearn.neighbors import KNeighborsClassifier\nTest_Embeddings = testing_model.predict((X_dev,y_dev_ohot))\nTrain_Embeddings = testing_model.predict((X_train,y_train_ohot))\n\ncol_mean = np.nanmean(Test_Embeddings, axis=0)\ninds = np.where(np.isnan(Test_Embeddings))\n#print(inds)\nTest_Embeddings[inds] = np.take(col_mean, inds[1])\n\ncol_mean = np.nanmean(Train_Embeddings, axis=0)                                                                                                                                \ninds = np.where(np.isnan(Train_Embeddings))\n#print(inds)\nTrain_Embeddings[inds] = np.take(col_mean, inds[1])\n\n#Test_Embeddings = np.nan_to_num(Test_Embeddings)\n\n##### Refining Test Embeddings\n#for i in range(Train_Embeddings.shape[0]):\n#    for j in range(Train_Embeddings.shape[1]):\n#        if(math.isnan(Train_Embeddings[i,j])):\n#            Train_Embeddings[i,j] == 0\n#        if(Train_Embeddings[i,j]>1e4):\n#            Train_Embeddings[i,j] == 1e4\n\n##### Refining Train Embeddings    \n#for i in range(Test_Embeddings.shape[0]):\n#    for j in range(Test_Embeddings.shape[1]):\n#        if(math.isnan(Test_Embeddings[i,j])):\n#            Test_Embeddings[i,j] == 0\n#        if(Test_Embeddings[i,j]>1e4 or math.isinf(Test_Embeddings[i,j])):\n#            Test_Embeddings[i,j] == 1e4\n\n#del(X_train_final,X_dev,X_dev_flipped,x_train_flipped)\n#gc.collect()\n\nTest_Accuracy_With_Train = []\nTest_Accuracy_With_Test = []\n                                                                     \nfor k in range(1,31):\n    knn = KNeighborsClassifier(n_neighbors=k,metric='euclidean')\n    knn.fit(Train_Embeddings,y_train)\n    Test_Accuracy_With_Train.append(knn.score(Test_Embeddings,y_dev))\n    knn.fit(Test_Embeddings,y_dev)\n    Test_Accuracy_With_Test.append(knn.score(Test_Embeddings,y_dev))\n\nprint('--------------------------------')\nprint(np.max(Test_Accuracy_With_Train))\nprint(np.max(Test_Accuracy_With_Test))\nprint('--------------------------------')\nprint(np.mean(Test_Accuracy_With_Train))\nprint(np.mean(Test_Accuracy_With_Test))\nprint('--------------------------------')\nprint((Test_Accuracy_With_Train)[0])\nprint((Test_Accuracy_With_Test)[0])\nprint('--------------------------------')\n\nplt.plot(np.arange(1,31),np.array(Test_Accuracy_With_Train),label='Test_Accuracy_With_Train')\nplt.plot(np.arange(1,31),np.array(Test_Accuracy_With_Test),label='Test_Accuracy_With_Test')\nplt.title('Testing Accuracy vs Number of Neighbors')\nplt.xlabel('Number of Neighbors')\nplt.ylabel('Test Accuracy')\nplt.legend()       \nplt.show()                 \n\nnp.savez_compressed('Test_Embeddings_Baseline.npz',Test_Embeddings)\nnp.savez_compressed('Train_Embeddings_Baseline.npz',Train_Embeddings)","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:38:37.414636Z","iopub.execute_input":"2021-08-02T10:38:37.415021Z","iopub.status.idle":"2021-08-02T10:38:54.170956Z","shell.execute_reply.started":"2021-08-02T10:38:37.414989Z","shell.execute_reply":"2021-08-02T10:38:54.169717Z"},"trusted":true},"execution_count":11,"outputs":[{"name":"stdout","text":"--------------------------------\n0.8943488943488943\n1.0\n--------------------------------\n0.5834561834561834\n0.6199017199017198\n--------------------------------\n0.8943488943488943\n1.0\n--------------------------------\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"## t-SNE","metadata":{}},{"cell_type":"code","source":"####### t-SNE Plot Generation\n###### Model Creation\n#with tpu_strategy.scope():          \n#    tsne_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-4].output)\n#    tsne_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n#tsne_model.summary()\n\n###### Model Predicted\n#embeddings_final = tsne_model.predict((X_dev,y_exp))\n\n###### t-SNE plot plotting\n##### Reduction to Lower Dimensions\ntsne_X_dev = TSNE(n_components=2,perplexity=30,learning_rate=10,n_iter=2000,n_iter_without_progress=50).fit_transform(Test_Embeddings)\n\n##### Plotting\nj = 0 # Index for rotating legend\nplt.rcParams[\"figure.figsize\"] = [24,16]\nmStyles = [\".\",\",\",\"o\",\"v\",\"^\",\"<\",\">\",\"1\",\"2\",\"3\",\"4\",\"8\",\"s\",\"p\",\"P\",\"*\",\"h\",\"H\",\"+\",\"x\",\"X\",\"D\",\"d\",\"|\",\"_\",\n           0,1,2,3,4,5,6,7,8,9,10,11,0,1,2,3,4,5,6,7,8,9,10]\nfor idx,color_index,marker_type in zip(list(np.arange(100)),sns.color_palette('muted',100),mStyles):\n    plt.scatter(tsne_X_dev[y_dev == idx, 0], tsne_X_dev[y_dev == idx, 1],marker=marker_type)\nplt.legend([str(j) for j in range(100)])\nplt.savefig('tsne_plot_5000_iters.png')\nplt.savefig('tsne_plot_5000_iters.pdf')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2021-08-02T10:38:54.172664Z","iopub.execute_input":"2021-08-02T10:38:54.172990Z","iopub.status.idle":"2021-08-02T10:38:58.271136Z","shell.execute_reply.started":"2021-08-02T10:38:54.172958Z","shell.execute_reply":"2021-08-02T10:38:58.269917Z"},"trusted":true},"execution_count":12,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1728x1152 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]}]}